﻿using System;
using Loja.Banco;
using Loja.Aplicação;
using Loja.Controles.Dados;
using System.Windows.Forms;
using System.Collections.Generic;

namespace Loja.Controles.Aplicação
{
    public class Controle
    {
        private LOJA loja;
        private Venda venda;
        private Compra compra;
        private Caixa caixa;
        private TipoCadastro tipoCadastro = new TipoCadastro();
        private TipoProduto tipoProduto = new TipoProduto();
        private Usuario usuario = new Usuario();
        private Cadastro cadastro = new Cadastro();
        private Vendedor vendedor = new Vendedor();
        private Produto produto = new Produto();
        private ItemVenda itemVenda = new ItemVenda();
        private ItemCaixa itemCaixa = new ItemCaixa();
        private CodigoBarras codigoBarras = new CodigoBarras();
        private VendedorControle vendedorControle;
        private UsuarioControle usuarioControle;
        private CadastroControle cliente;
        private ProdutoControle produtoControle;
        private CodigoBarrasControle codigoBarrasControle;
        private ItemVendaControle itemVendaControle;
        private ItemCaixaControle itemCaixaControle;
        private TipoCadastroControle tipoCadastroControle;
        private TipoProdutoControle tipoProdutoControle;
        private CaixaControle caixaControle;
        private VendaControle vendaControle;
        private CompraControle compraControle;
        private ItemCompra itemCompra;
        private ItemCompraControle itemCompraControle;


        /***********************Parametros*******************/

        private String codigo;
        private String descricao;

        public String Codigo
        {
            get { return codigo; }
            set { codigo = value; }
        }
        public String Descricao
        {
            get { return descricao; }
            set { descricao = value; }
        }

        public void SetaParametros(String valor, String nome)
        {
            codigo = valor;
            descricao = nome;
        }

        public void LimpaParametros()
        {
            codigo = "";
            descricao = "";
        }


        /**********************Construtor********************/
        public Controle()
        {
            loja = new LOJA();
        }


        public void IniciarVenda()
        {
            venda = new Venda();
        }
        
        /********Relatorio de vendas****************************/
        public Object BuscaViewVendas(DateTime dataInicio, DateTime dataFim)
        {                        
            vendaControle = new VendaControle(loja);
            return vendaControle.RelatorioVendas(dataInicio, dataFim);
        }

        /********Lista os tipo de cadastro ativos**************/
        public Object BuscaTipoCadastroAtivos()
        {
            tipoCadastroControle = new TipoCadastroControle(loja);
            return tipoCadastroControle.Listar();
        }

        /********Lista todos os tipo de cadastro**************/
        public Object BuscaTipoCadastro()
        {
            tipoCadastroControle = new TipoCadastroControle(loja);
            return tipoCadastroControle.ListarTodos();
        }
        /********Consulta like tipo de cadastro***************/
        public Object BuscaTipoCadastro(String descricao)
        {
            tipoCadastroControle = new TipoCadastroControle(loja);
            return tipoCadastroControle.BuscarCampo(descricao);
        }
        /*************Abrir Tipo Cadastro*******************/
        public TipoCadastro AbrirTipoCadastro(Int32 codigo)
        {
            tipoCadastroControle = new TipoCadastroControle(loja);

            var tipo = tipoCadastroControle.Buscar(codigo);
            return tipo;
        }

        /*************Atualizar Tipo Cadastro*******************/
        public Boolean AtualizarTipoCadastro(String codigoParametro, String descricaoParametro)
        {
            tipoCadastroControle = new TipoCadastroControle(loja);
            try
            {
                tipoCadastro = tipoCadastroControle.Buscar(Convert.ToInt32(codigoParametro));
                tipoCadastro.Descricao = descricaoParametro;
                tipoCadastroControle.Alterar(tipoCadastro);
                return true;
            }
            catch
            {
                return false;
            }
        }
        /**************Desativar Tipo Cadastro******************/
        public Boolean DesativarTipoCadastro(String codigoParametro)
        {
            tipoCadastroControle = new TipoCadastroControle(loja);
            try
            {
                tipoCadastro = tipoCadastroControle.Buscar(Convert.ToInt32(codigoParametro));
                tipoCadastroControle.Excluir(tipoCadastro);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /************Inserir Tipo Cadastro*******************/
        public Boolean InserirTipoCadastro(String descricaoParametro)
        {
            tipoCadastroControle = new TipoCadastroControle(loja);
            tipoCadastro = new TipoCadastro();
            try
            {
                tipoCadastro.Descricao = descricaoParametro;
                tipoCadastroControle.Salvar(tipoCadastro);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /*************Abrir Tipo Cadastro*******************/
        public Cadastro AbrirCadastro(Int32 codigo)
        {
            cliente = new CadastroControle(loja);

            var cadastro = cliente.Buscar(codigo);
            return cadastro;
        }

        /********Lista todos os tipo de produto**************/
        public Object BuscaTipoProduto()
        {
            tipoProdutoControle = new TipoProdutoControle(loja);
            return tipoProdutoControle.Listar();
        }
        /********Consulta like tipo de produto***************/
        public Object BuscaTipoProduto(String descricao)
        {
            tipoProdutoControle = new TipoProdutoControle(loja);
            return tipoProdutoControle.BuscarCampo(descricao);
        }

        /*************Abrir Tipo Produto*******************/
        public TipoProduto AbrirTipoProduto(Int32 codigo)
        {
            tipoProdutoControle = new TipoProdutoControle(loja);

            var tipo = tipoProdutoControle.Buscar(codigo);
            return tipo;
        }

        /*************Atualizar Tipo Produto*******************/
        public Boolean AtualizarTipoProduto(String codigoParametro, String descricaoParametro)
        {
            tipoProdutoControle = new TipoProdutoControle(loja);
            try
            {
                tipoProduto = tipoProdutoControle.Buscar(Convert.ToInt32(codigoParametro));
                tipoProduto.Descricao = descricaoParametro;
                tipoProdutoControle.Alterar(tipoProduto);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /************Inserir Tipo Produto*******************/
        public Boolean InserirTipoProduto(String descricaoParametro)
        {
            tipoProdutoControle = new TipoProdutoControle(loja);
            tipoProduto = new TipoProduto();
            try
            {
                tipoProduto.Descricao = descricaoParametro;
                tipoProdutoControle.Salvar(tipoProduto);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /**************Desativar Tipo Produto******************/
        public Boolean DesativarTipoProduto(String codigoParametro)
        {
            tipoProdutoControle = new TipoProdutoControle(loja);
            try
            {
                tipoProduto = tipoProdutoControle.Buscar(Convert.ToInt32(codigoParametro));
                tipoProdutoControle.Excluir(tipoProduto);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /********************Busca Vendedor******************/
        public Object BuscaVendedor()
        {
            vendedorControle = new VendedorControle(loja);
            return vendedorControle.Listar();
        }
        
        public Object BuscaVendedorVendaP()
        {
            vendedorControle = new VendedorControle(loja);
            return vendedorControle.ListarVendedor();
        }

        /********Consulta like vendedor***************/
        public Object BuscaVendedor(String descricao)
        {
            vendedorControle = new VendedorControle(loja);
            return vendedorControle.BuscarVendedorCampo(descricao);
        }

        public Boolean DesativarVendedor(Object vendedorParametro)
        {
            vendedor = (Vendedor)vendedorParametro;
            vendedorControle = new VendedorControle(loja);
            try
            {
                vendedor.Desativado = true;
                vendedorControle.Alterar(vendedor);
                return true;
            }
            catch
            {
                return false;
            }
        }

        public Boolean NovoVendedor(Object vendedorParametro)
        {
            vendedor = (Vendedor)vendedorParametro;
            vendedorControle = new VendedorControle(loja);
            try
            {                
                vendedorControle.Salvar(vendedor);
                return true;
            }
            catch
            {
                return false;
            }
        }

        public Boolean AlterarVendedor(Object vendedorParametro)
        {
            vendedor = (Vendedor)vendedorParametro;
            vendedorControle = new VendedorControle(loja);
            try
            {
                vendedorControle.Alterar(vendedor);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /*********************Busca Cliente********************/
        public Object BuscaCliente()
        {
            cliente = new CadastroControle(loja);
            return cliente.Listar();
        }

        public Object BuscaClienteVendaP()
        {
            cliente = new CadastroControle(loja);
            return cliente.ListarClienteVenda();
        }

        public Object BuscaClienteTipoCadastro(Object tipoCadastro)
        {
            cliente = new CadastroControle(loja);
            return cliente.ListarClienteTipoCadastro((TipoCadastro)tipoCadastro);
        }

        public Cadastro BuscaCadastroCompra(Int32 cadastro)
        {
            cliente = new CadastroControle(loja);
            return cliente.BuscaCadastroCompra(cadastro);
        }

        /********Consulta like Cliente*************************/
        public Object BuscaCliente(String descricao)
        {
            cliente = new CadastroControle(loja);
            return cliente.BuscarClienteCampo(descricao);
        }

        public Object BuscaClienteTipoCadastro(String descricao, Object tipoCadastro)
        {
            cliente = new CadastroControle(loja);
            return cliente.BuscarClienteCampoTipoCadastro(descricao, (TipoCadastro)tipoCadastro);
        }

        public Boolean DesativarCadastro(Object cadastroParametro)
        {
            cadastro = (Cadastro)cadastroParametro;
            cliente = new CadastroControle(loja);
            try
            {
                cadastro.Desativado = true;
                cliente.Atualizar(cadastro);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /************Inserir Cadastro*******************/
        public Boolean InserirCadastro(String celParametro,
                                       String cepParametro,
                                       String cnpjParametro,
                                       String cpfParametro,
                                       String enderParametro,
                                       String foneParametro,
                                       String ieParametro,
                                       String nomeParametro,
                                       String numeroParametro,
                                       String rgParametro,
                                       String obsParametro,
                                       DateTime dtCadastroParametro,
                                       DateTime? dtNasctoParametro,
                                       String cidadeParametro,                                       
                                       ComboBox tipo
                                      )
        {
            cliente = new CadastroControle(loja);
            cadastro = new Cadastro();
            try
            {
                cadastro.Celular = celParametro;
                cadastro.CEP = cepParametro;
                cadastro.Cidade = cidadeParametro;
                cadastro.CNPJ = cnpjParametro;                
                cadastro.CPF = cpfParametro;
                cadastro.DataCadastro = dtCadastroParametro;
                cadastro.DataNascto = dtNasctoParametro;
                cadastro.Endereco = enderParametro;
                cadastro.InscricaoEstadual = ieParametro;
                cadastro.Nome = nomeParametro;
                cadastro.Numero = numeroParametro;                    
                cadastro.Observacao = obsParametro;
                cadastro.RG = rgParametro;
                cadastro.Telefone = foneParametro;
                BindingSource bs = new BindingSource();
                bs.DataSource = tipo.SelectedValue;                
                cadastro.TipoCadastro = (TipoCadastro) bs.Current;
                cliente.Salvar(cadastro);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /************Atualizar Cadastro*******************/
        public Boolean AtualizarCadastro(  Cadastro cadastro,
                                           String celParametro,
                                           String cepParametro,
                                           String cnpjParametro,
                                           String cpfParametro,
                                           String enderParametro,
                                           String foneParametro,
                                           String ieParametro,
                                           String nomeParametro,
                                           String numeroParametro,
                                           String rgParametro,
                                           String obsParametro,
                                           DateTime? dtNasctoParametro,
                                           String cidadeParametro,
                                           ComboBox tipo
                                      )
        {
            cliente = new CadastroControle(loja);
            try
            {
                cadastro.Celular = celParametro;
                cadastro.CEP = cepParametro;
                cadastro.Cidade = cidadeParametro;
                cadastro.CNPJ = cnpjParametro;
                cadastro.CPF = cpfParametro;                
                cadastro.DataNascto = dtNasctoParametro;
                cadastro.Endereco = enderParametro;
                cadastro.InscricaoEstadual = ieParametro;
                cadastro.Nome = nomeParametro;
                cadastro.Numero = numeroParametro;
                cadastro.Observacao = obsParametro;
                cadastro.RG = rgParametro;
                cadastro.Telefone = foneParametro;
                BindingSource bs = new BindingSource();
                bs.DataSource = tipo.SelectedValue;
                cadastro.TipoCadastro = (TipoCadastro)bs.Current;
                cliente.Atualizar(cadastro);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /***************Lista todos os produtos****************/
        public Object BuscaProduto()
        {
            produtoControle = new ProdutoControle(loja);
            return produtoControle.Listar();
        }

        /********Consulta like produto***************/
        public Object BuscaProdutoCampo(String campo)
        {
            produtoControle = new ProdutoControle(loja);
            return produtoControle.BuscarProdutoCampo(campo);
        }

        public Boolean DesativarProduto(Object produtoParametro)
        {
            produto = (Produto)produtoParametro;
            produtoControle = new ProdutoControle(loja);
            codigoBarrasControle = new CodigoBarrasControle(loja);
            try
            {
                foreach (CodigoBarras codigo in produto.CodigoBarras)
                {
                    codigo.Desativado = true;
                    codigoBarrasControle.Atualizar(codigo);                              
                }
                
                produto.Desativado = true;               
                produtoControle.Alterar(produto);                
                return true;
            }
            catch
            {
                return false;
            }
        }

        /*********************Busca Produto********************/

        public Boolean BuscaProduto(String barras)
        {
            produtoControle = new ProdutoControle(loja);
            produto = produtoControle.BuscarCodigo(barras);
            if (produto.Produto_ID == 0)
                return false;
            else
            {
                SetaParametros(Convert.ToString(produto.Produto_ID), produto.Descricao);
                return true;
            }
        }

        public Produto BuscaProduto(Int32 produto_id)
        {
            produtoControle = new ProdutoControle(loja);

            return produtoControle.BuscarProdutoCodigo(produto_id);
        }

        public List<CodigoBarras> ListaBarras(Int32 produto)
        {
            produtoControle = new ProdutoControle(loja);

            return produtoControle.ListaBarras(produto);
        }
/*
        public String BuscaQuantidade(Int32 parametro)
        {
            itemEstoqueControle = new ItemEstoqueControle(loja);

            return itemEstoqueControle.BuscarQuantidade(parametro);
        }
        */

        /***Verifica sé há a quantidade de itens em Estoque***/

  /*      public Boolean VerificaEstoque(Int32 qtd, DataGridView data)
        {
            itemEstoqueControle = new ItemEstoqueControle(loja);

            Int32 qtdLista = 0;

            for (Int32 i = 0; i < data.RowCount; i++)
            {
                if (Convert.ToInt32(data.Rows[i].Cells[4].Value) == produto.Produto_ID)
                    qtdLista += Convert.ToInt32(data.Rows[i].Cells[1].Value);
            }

        //    itemEstoque = itemEstoqueControle.Valida(produto.Produto_ID);

            if ((qtd + qtdLista) <= itemEstoque.Quantidade)
                return true;
            else
            {
                SetaParametros(itemEstoque.Quantidade.ToString(), "");
                return false;
            }
        }
*/
        /*********************Busca Item********************/

        public DataGridView BuscaItem(DataGridView data, Int32 qtd, String barras)
        {
            Boolean tem = false;
            Int32 linha = 0;
            codigoBarras = produtoControle.BuscarBarras(barras);

            for (Int32 i = 0; i < data.RowCount; i++)
            {
                if (Convert.ToString(data.Rows[i].Cells[4].Value) == codigoBarras.Codigo)
                {                    
                    tem = true;
                    linha = i;
                }
            }

            if (tem)
            {
                data.Rows[linha].Cells[1].Value = (Convert.ToInt32(data.Rows[linha].Cells[1].Value) + qtd);                
                data.Rows[linha].Cells[3].Value = ((Convert.ToInt32(data.Rows[linha].Cells[1].Value)) * (Convert.ToDecimal(data.Rows[linha].Cells[2].Value)));
            }
            else
                data.Rows.Add(produto.Descricao, qtd, codigoBarras.Valor, (codigoBarras.Valor * qtd), codigoBarras.Codigo, 0, 0);

            return data;
        }

        public void BuscaClienteVenda()
        {
            cliente = new CadastroControle(loja);
            cadastro = cliente.Buscar(1);
            SetaParametros(cadastro.Cadastro_ID.ToString(), cadastro.Nome);
        }

        public void BuscaVendedorVenda()
        {
            vendedorControle = new VendedorControle(loja);
            vendedor = vendedorControle.Buscar(1);
            SetaParametros(vendedor.Vendedor_ID.ToString(), vendedor.Nome);
        }

        public void BuscaUsuario(String login)
        {
            usuarioControle = new UsuarioControle(loja);
            usuario = usuarioControle.Buscar(login);

            SetaParametros(usuario.Usuario_ID.ToString(), usuario.Nome);
        }
        /********Consulta todos usuários************************/
        public object ListaUsuario()
        {
            usuarioControle = new UsuarioControle(loja);
            return usuarioControle.Listar();
        }

        public Boolean DesativarUsuario(Object usuarioParametro)
        {
            usuario = (Usuario)usuarioParametro;             
            usuarioControle = new UsuarioControle(loja);
            try
            {
                usuario.Desativado = true;
                usuarioControle.Atualizar(usuario);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /********Consulta like usuários*************************/
        public Object ListaUsuario(String descricao)
        {
            usuarioControle = new UsuarioControle(loja);
            return usuarioControle.ListarUsuarioCampo(descricao);
        }

        public Boolean GerarVenda(String vendedorParametro, String clienteParametro, String valorTotal, String desconto, String formaPagamento)
        {
            cliente = new CadastroControle(loja);
            vendedorControle = new VendedorControle(loja);           
            

            try
            {
                venda.Usuario = usuario;
                venda.Cadastro = cliente.Buscar(Convert.ToInt32(clienteParametro));
                venda.Vendedor = vendedorControle.Buscar(Convert.ToInt32(vendedorParametro));
                venda.ValorVenda = Convert.ToDecimal(valorTotal);
                venda.FormaPagamento = formaPagamento;
                if (desconto == "")
                    venda.ValorDesconto = 0;
                else
                    venda.ValorDesconto = Convert.ToDecimal(desconto);
                venda.DataEmissao = DateTime.Now;
                venda.Cancelado = false;
                venda.Desativado = false;

                vendaControle = new VendaControle(loja);

                vendaControle.Salvar(venda);

                return true;
            }
            catch(Exception e)
            {
                MessageBox.Show(e.ToString());
                return false;
            }
        }

        public Boolean GerarVendaCompleto(String vendedorParametro, 
                                          String clienteParametro,
                                          String valorTotal, 
                                          String desconto,
                                          String formaPagamento,
                                          DataGridView listProdutos
                                         )
        {
            cliente = new CadastroControle(loja);
            vendedorControle = new VendedorControle(loja);
            codigoBarras = new CodigoBarras();
            try
            {
                venda.Usuario = usuario;
                venda.Cadastro = cliente.Buscar(Convert.ToInt32(clienteParametro));
                venda.Vendedor = vendedorControle.Buscar(Convert.ToInt32(vendedorParametro));
                venda.ValorVenda = Convert.ToDecimal(valorTotal);
                venda.FormaPagamento = formaPagamento;                                     
                if (desconto == "")
                    venda.ValorDesconto = 0;
                else
                    venda.ValorDesconto = Convert.ToDecimal(desconto);
                venda.DataEmissao = DateTime.Now;
                venda.Cancelado = false;
                venda.Desativado = false;
                //insere itemvenda                                
                
                foreach (DataGridViewRow linha in listProdutos.Rows)
                {
                    if (linha.Index < (listProdutos.Rows.Count))
                    {
                        codigoBarras = produtoControle.BuscarBarras((linha.Cells[4].Value).ToString());
                        itemVenda.Quantidade = Convert.ToInt32(linha.Cells[1].Value);
                        itemVenda.ValorUnitario = Convert.ToDecimal(linha.Cells[2].Value);
                        itemVenda.ValorTotal = Convert.ToDecimal(linha.Cells[3].Value);
                        itemVenda.CodigoBarras = codigoBarras;
                        itemVenda.Desativado = false;
                        itemVenda.Venda = venda;
                        //Atualiza o estoque
                        codigoBarras.Quantidade = codigoBarras.Quantidade - itemVenda.Quantidade;
                        venda.ItemVenda.Add(itemVenda);
                        itemVenda = new ItemVenda();
                    }
                }                                

                //Gera Item Caixa
                ItemCaixa itemCaixa = new ItemCaixa();
                itemCaixa.DataLancamento = DateTime.Now;
                itemCaixa.Valor = venda.ValorVenda;
                itemCaixa.TipoLancamento = "C";
                itemCaixa.Descricao = "VENDA";
                itemCaixa.Caixa = caixa;
                itemCaixa.Venda = venda;
                itemCaixa.Desativado = false;              

                venda.ItemCaixa.Add(itemCaixa);
                 
                vendaControle = new VendaControle(loja);

                vendaControle.Salvar(venda);

                IniciarVenda();

                return true;
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
                return false;
            }
        }

        public Boolean AtualizarEstoque(CodigoBarras novo, Int32 quantidade)
        {
            try
            {

                produtoControle = new ProdutoControle(loja);

                novo.Quantidade = (novo.Quantidade - quantidade);

                produtoControle.AlterarBarras();

                return true;
            }

            catch
            {
                return false;
            }
        }

        public Boolean GerarItemVenda(DataGridView data)
        {
           
            itemVendaControle = new ItemVendaControle(loja);

            foreach (DataGridViewRow linha in data.Rows)
            {
                if (linha.Index < (data.Rows.Count))
                {
                    itemVenda.Quantidade = Convert.ToInt32(linha.Cells[1].Value);
                    itemVenda.ValorUnitario = Convert.ToDecimal(linha.Cells[2].Value);
                    itemVenda.ValorTotal = Convert.ToDecimal(linha.Cells[3].Value);
                    itemVenda.CodigoBarras = produtoControle.BuscarBarras((linha.Cells[4].Value).ToString());
                    itemVenda.Desativado = false;
                    itemVenda.Venda = venda;
                    itemVendaControle.Salvar(itemVenda);

                    if (AtualizarEstoque(produtoControle.BuscarBarras((linha.Cells[4].Value).ToString()), itemVenda.Quantidade))
                        itemVenda = new ItemVenda();
                }
            }
            return true;
        }

        public Boolean AbrirCaixa(DateTime dataParametro, Decimal valorAberturaParametro)
        {
            caixaControle = new CaixaControle(loja);
            try
            {
                caixa = new Caixa();

                caixa.DataAbertura = dataParametro;
                caixa.StatusCaixa = true;
                caixa.Usuario = usuario;
                caixa.SaldoInicial = valorAberturaParametro;
                caixa.Desativado = false;

                caixaControle.Salvar(caixa);

                return true;
            }

            catch
            {
                return false;
            }
        }

        public Boolean AbrirCaixaFechado(Int32 caixaParametro)
        {
            caixaControle = new CaixaControle(loja);
            try
            {
                
                if (caixaControle.VerificaCaixaAberto())//verifica se existe caixas abertos
                {
                    if (!caixaControle.BuscaCaixaFechado(caixaParametro))
                    {
                        Caixa caixa = caixaControle.BuscaCaixa(caixaParametro);
                                                
                        caixa.DataFechamento = null;
                        caixa.StatusCaixa = true;
                        caixa.Usuario = usuario;
                        caixa.Desativado = false;

                        caixaControle.AtualizaCaixa(caixa);

                        return true;
                    }
                    else
                        return false;
                }
                else
                    return false;               
            }

            catch
            {
                return false;
            }
        }

        public Boolean FecharCaixa(Int32 caixaParametro, DateTime dataFechamentoParametro)
        {
            caixaControle = new CaixaControle(loja);
            try
            {
                Caixa caixa = caixaControle.BuscaCaixa(caixaParametro);
                caixa.DataFechamento = dataFechamentoParametro;
                caixa.StatusCaixa = false;
                caixaControle.AtualizaCaixa(caixa);
                return true;
            }

            catch
            {
                return false;
            }
        }

        public Boolean VerificaDataFechamento(Int32 caixaParametro, DateTime dataFechamentoParametro)
        {
            caixaControle = new CaixaControle(loja);
            try
            {
                Caixa caixa = caixaControle.BuscaCaixa(caixaParametro);

                if (caixa.DataAbertura <= dataFechamentoParametro)
                    return true;
                else
                    return false;
            }

            catch
            {
                return false;
            }
        }

        public Boolean BuscaCaixa()
        {
            caixaControle = new CaixaControle(loja);

            caixa = caixaControle.BuscaCaixa();

            return true;
        }

        public Object BuscaCaixa(DateTime dataInicio, DateTime dataFim)
        {
            caixaControle = new CaixaControle(loja);
            return caixaControle.BuscaCaixa(dataInicio, dataFim);
        }        

        public Object BuscaItemCaixa(Int32 caixa_id)
        {
            itemCaixaControle = new ItemCaixaControle(loja);

            return itemCaixaControle.BuscaItens(caixa_id);
        }

        public Object AlterarItemCaixa(Int32 itemCaixa)
        {
            itemCaixaControle = new ItemCaixaControle(loja);

            return itemCaixaControle.BuscaItemCaixa(itemCaixa);
        }

        public Boolean VerificarCaixa()
        {
            caixaControle = new CaixaControle(loja);

            if (caixaControle.VerificaCaixaAberto())
            {
                return true;
            }
            else
                return false;
        }

        public Boolean VerificarCaixa(Int32 caixaParametro)
        {
            caixaControle = new CaixaControle(loja);

            if (caixaControle.VerificaCaixaAberto(caixaParametro))
            {
                return true;
            }
            else
                return false;
        }


        public Boolean NovoItemCaixa(String tipo)
        {
            itemCaixaControle = new ItemCaixaControle(loja);
            caixaControle = new CaixaControle(loja);

            try
            {
                itemCaixa.DataLancamento = DateTime.Now;
                itemCaixa.Valor = venda.ValorVenda;
                itemCaixa.TipoLancamento = tipo;

                if (tipo == "C")
                {
                    itemCaixa.Descricao = "VENDA";
                    itemCaixa.Caixa = caixa;
                }
                else
                {
                    itemCaixa.Descricao = "ESTORNO DE VENDA";
                    itemCaixa.Caixa = caixaControle.BuscaCaixa();
                }

                
                itemCaixa.Venda = venda;
                itemCaixa.Desativado = false;

                itemCaixaControle.Salvar(itemCaixa);
                IniciarVenda();
                itemCaixa = new ItemCaixa();

                return true;
            }
            catch(Exception e)
            {
                MessageBox.Show(e.ToString());
                return false;
            }                        
        }
        public Boolean InserirItemCaixa(String valorParametro, String tipoParametro, Int32 caixaParametro, String descricaoParametro, DateTime dataParametro)
        {
            itemCaixa = new ItemCaixa();
            itemCaixaControle = new ItemCaixaControle(loja);
            caixaControle = new CaixaControle(loja);            
            try
            {
                itemCaixa.DataLancamento = dataParametro;
                itemCaixa.Valor = Convert.ToDecimal(valorParametro);
                itemCaixa.TipoLancamento = tipoParametro; 
                itemCaixa.Descricao = descricaoParametro;
                itemCaixa.Caixa = caixaControle.BuscaCaixa(caixaParametro);                
                itemCaixa.Desativado = false;
                itemCaixaControle.Salvar(itemCaixa);

                return true;
            }
            catch
            {
                return false;
            }
        }

        public Boolean AtualizarItemCaixa(Int32 itemCaixaParametro,String valorParametro, String tipoParametro, String descricaoParametro, DateTime dataParametro)
        {
            itemCaixa = new ItemCaixa();
            itemCaixaControle = new ItemCaixaControle(loja);            
            try
            {
                itemCaixa = itemCaixaControle.BuscaItemCaixa(itemCaixaParametro);
                itemCaixa.DataLancamento = dataParametro;
                itemCaixa.Valor = Convert.ToDecimal(valorParametro);
                itemCaixa.TipoLancamento = tipoParametro;
                itemCaixa.Descricao = descricaoParametro;                
                itemCaixa.Desativado = false;
                itemCaixaControle.Atualizar(itemCaixa);

                return true;
            }
            catch
            {
                return false;
            }
        }

        public ItemCaixa BuscaAlterarItemCaixa(Int32 itemCaixa_id)
        {
            itemCaixaControle = new ItemCaixaControle(loja);

            return itemCaixaControle.BuscaItemCaixa(itemCaixa_id);
        }

        /**************Busca Vendas*******************/
        public Object ListarVenda(DateTime datainicio, DateTime datafim)
        {
            vendaControle = new VendaControle(loja);
            return vendaControle.RelatorioVendas(datainicio, datafim);
        }

        public Venda BuscarVenda(Int32 parametro)
        {
            vendaControle = new VendaControle(loja);
            return vendaControle.Buscar(parametro);
        }

        public Object BuscarItemVenda(Int32 parametro)
        {
            itemVendaControle = new ItemVendaControle(loja);
            return itemVendaControle.Buscar(parametro);
        }

        /****************Estorno Venda***************/

        public Boolean EstornarVenda(Int32 parametro)
        {
            try
            {
                venda = new Venda();
                itemVendaControle = new ItemVendaControle(loja);

                venda = vendaControle.BuscaVendaEstorno(parametro);

                List<ItemVenda> itens = itemVendaControle.BuscarItensVenda(venda);

                if (this.EstornaItensVenda(itens, itemVendaControle))
                {
                    venda = new Venda();
                    venda = vendaControle.BuscaVendaEstorno(parametro);
                    vendaControle.CancelarVenda(venda);
                    NovoItemCaixa("D");
                    return true;
                }
                return false;
                
            }
            catch
            {
                return false;
            }
        }

        public Boolean VerificaVenda(Int32 parametro)
        {
            try
            {
                venda = new Venda();
                venda = vendaControle.BuscaVendaEstorno(parametro);

                if (venda.Cancelado)
                    return false;
                else
                    return true;
            }
            catch 
            {
                return true;
            }
        }

        public Boolean EstornaItensVenda(List<ItemVenda> itens, ItemVendaControle con)
        {
            try
            {
                foreach (ItemVenda item in itens)
                {                    
                    con.CancelarItem(item);
                }

                return true;
            }

            catch 
            {
                return false;
            }
        }

        /*** Carrega Estrato Caixa ***/

        public vw_Caixas BuscaExtratoCaixa(Int32 parametro)
        {
            itemCaixaControle = new ItemCaixaControle(loja);
            return  itemCaixaControle.BuscaItensCaixa(parametro);
        }

        public vw_Caixas BuscaCaixaExtrato(Int32 parametro)
        {
            caixaControle = new CaixaControle(loja);
            return caixaControle.BuscaItensCaixa(parametro);
        }

        public vw_ExtratoCaixa BuscaExtratoResumo(Int32 parametro)
        {
            itemCaixaControle = new ItemCaixaControle(loja);
            return itemCaixaControle.BuscaExtratoResumo(parametro);
        }

        /*** Validaçoes Codigo de Barras Tela de Produtos  ***/

        public Boolean ExisteCodigoBarras(String barras)
        {
            produtoControle = new ProdutoControle(loja);
            return produtoControle.ExiteBarras(barras);
        }

        public String BuscaNomeProduto(String codigo)
        {
            produtoControle = new ProdutoControle(loja);
            return produtoControle.BuscaNomeProduto(codigo);
        }

        /*** Tela venda armazenando produto ***/

        public Boolean SalvarNovoProduto(Produto novoProduto, DataGridView dados, Int32 parametroTP)
        {
            //LOJA loja = new LOJA();
            produtoControle = new ProdutoControle(loja);           
            tipoProdutoControle = new TipoProdutoControle(loja);           

            novoProduto.TipoProduto = tipoProdutoControle.Buscar(parametroTP);
            //Alterado 04/11/2012 pois estava dando erro de relacionamento
            //produtoControle.Salvar(novoProduto);
/*
            itemEstoque = new ItemEstoque();

            itemEstoque.Desativado = false;
            itemEstoque.Produto = novoProduto;
            itemEstoque.Quantidade = qtdItens;

            itemEstoqueControle.Salvar(itemEstoque);
*/
            foreach (DataGridViewRow linha in dados.Rows)
            {
                if (linha.Index < (dados.Rows.Count))
                {
                    codigoBarras = new CodigoBarras();

                    if (linha.Cells[4].Value.ToString() == "SIM")
                    {
                        codigoBarras.Produto = novoProduto;
                        codigoBarras.Codigo = linha.Cells[0].Value.ToString();
                        codigoBarras.Valor = Convert.ToDecimal(linha.Cells[1].Value);
                        codigoBarras.Unidade = linha.Cells[2].Value.ToString();
                        codigoBarras.Quantidade = Convert.ToInt32(linha.Cells[3].Value);
                        //Alterado 04/11/2012 pois estava dando erro de relacionamento
                        novoProduto.CodigoBarras.Add(codigoBarras);
                        //codigoBarrasControle.Salvar(codigoBarras);
                    }
                }

            }
            produtoControle.Salvar(novoProduto);
            
            return true;
        }               

        public Boolean AlterarProduto(Produto novoProduto, DataGridView dados, Int32 parametroTP, List<String> codigos)
        {
            produtoControle = new ProdutoControle(loja);
            tipoProdutoControle = new TipoProdutoControle(loja);

            novoProduto.TipoProduto = tipoProdutoControle.Buscar(parametroTP);

            produtoControle.Alterar(novoProduto);

            foreach (String codigo in codigos)
            {
                codigoBarras = new CodigoBarras();
                codigoBarras = produtoControle.BuscarBarras(codigo);
                codigoBarras.Desativado = true;
                produtoControle.AlterarBarras();
            }
            
            foreach (DataGridViewRow linha in dados.Rows)
            {
                if (linha.Index < (dados.Rows.Count))
                {
                    codigoBarras = new CodigoBarras();

                    if (linha.Cells[4].Value.ToString() == "SIM")
                    {
                        codigoBarras.Produto = novoProduto;
                        codigoBarras.Desativado = false;
                        codigoBarras.Codigo = linha.Cells[0].Value.ToString();
                        codigoBarras.Valor = Convert.ToDecimal(linha.Cells[1].Value);
                        codigoBarras.Unidade = linha.Cells[2].Value.ToString();
                        codigoBarras.Quantidade = Convert.ToInt32(linha.Cells[3].Value);

                        produtoControle.SalvarBarras(codigoBarras);
                    }
                    else
                    {
                        produtoControle = new ProdutoControle(loja);

                        codigoBarras = produtoControle.BuscarBarras(linha.Cells[0].Value.ToString());

                        codigoBarras.Codigo = linha.Cells[0].Value.ToString();
                        codigoBarras.Desativado = false;
                        codigoBarras.Valor = Convert.ToDecimal(linha.Cells[1].Value);
                        codigoBarras.Unidade = linha.Cells[2].Value.ToString();
                        codigoBarras.Quantidade = Convert.ToInt32(linha.Cells[3].Value);

                        produtoControle.AlterarBarras();
                    }
                }
            }

            


            return true;
        }


        public Boolean ValidaCaixaVenda()
        {
            caixaControle = new CaixaControle(loja);

            if (caixaControle.VerificaCaixaAberto())
                return false;
            else
                return true;
        }

        public Boolean CaixaAtual()
        {
            caixaControle = new CaixaControle(loja);

            return caixaControle.VerificaCaixaVendaAtual();
        }

        public List<vw_AlertaEstoque> AvisoEstoque()
        {
            produtoControle = new ProdutoControle(loja);
            return produtoControle.AlertaEstoque();
        }

        /***  Login  ***/

        public Boolean ProcuraLogin(String nome)
        {
            usuarioControle = new UsuarioControle(loja);
            return usuarioControle.ProcuraUser(nome);
        }

        public Boolean Login(String login, String senha)
        {
            usuarioControle = new UsuarioControle(loja);
            return usuarioControle.Login(login, senha);
        }

        public void BuscaUsuarioAtual()
        {
            SetaParametros(usuario.Usuario_ID.ToString(), usuario.Nome);
        }

        public Boolean SalvarUsuario(Usuario novoUsuario)
        {
            try
            {
                usuarioControle = new UsuarioControle(loja);
                usuarioControle.Salvar(novoUsuario);
                return true;
            }
            catch
            {
                return false;
            }
        }

        public Boolean AtualizarUsuario(Usuario usuarioAlterar)
        {
            try
            {
                usuarioControle = new UsuarioControle(loja);
                usuarioControle.Atualizar(usuarioAlterar);
                return true;
            }
            catch
            {
                return false;
            }
        }

        private CodigoBarras novoCodigo;

        public void SetBarras(CodigoBarras parametro)
        {
            this.novoCodigo = parametro;
        }

        public CodigoBarras GetBarras()
        {
            return this.novoCodigo;
        }

        public Object ListaProdutosConsulta()
        {
            produtoControle = new ProdutoControle(loja);
            return produtoControle.ListaProdutosConsulta();
        }

        public Object ListaProdutosPorNome(String parametro)
        {
            produtoControle = new ProdutoControle(loja);
            return produtoControle.ListaProdutosPorNome(parametro);
        }

        public Object ListaProdutosPorCodigo(String parametro)
        {
            produtoControle = new ProdutoControle(loja);
            return produtoControle.ListaProdutosPorCodigo(parametro);
        }

        public Object BuscaProdutoCompra(Int32        produtoParametro, 
                                         Int32        qtdadeProdutoParametro, 
                                         DataGridView dgDados, 
                                         Compra       compraParametro)
        {
            BindingSource bs = new BindingSource();
            bs.DataSource = dgDados.DataSource;
            
            produtoControle = new ProdutoControle(loja);
		    produto = produtoControle.BuscaProdutoCompra(produtoParametro);

            bool flag = false;            
            
            foreach (ItemCompra item in bs.List)
            {
                if (item.Produto.Produto_ID == produto.Produto_ID)
                {
                    item.Quantidade = item.Quantidade + qtdadeProdutoParametro;
                    item.ValorTotal = item.ValorUnitario * item.Quantidade;
                    itemCompra = item;
                    flag = true;
                    break;
                }
            }

            if (!flag)
            {
                itemCompra = new ItemCompra();
                itemCompra.Produto = produto;
                itemCompra.Quantidade = qtdadeProdutoParametro;
                itemCompra.ValorUnitario = produto.CustoUnitario;
                itemCompra.ValorTotal = itemCompra.ValorUnitario * qtdadeProdutoParametro;
            }

            compraParametro.ItemCompra.Add(itemCompra);
            

            return compraParametro.ItemCompra;            
        }

        public Boolean FinalizaCompra(DateTime     dataCompraParametro, 
                                      String       valorCompraParametro, 
                                      String       valorDescontoParametro, 
                                      String       obsParametro, 
                                      Int32        cadastroParametro,
                                      Compra       compraParametro,
                                      DataGridView data)
        {
            //compra = new Compra();
            cliente = new CadastroControle(loja);            
            try
            {
                compraParametro.Cadastro = cliente.Buscar(cadastroParametro);
                compraParametro.DataCompra = dataCompraParametro;
                compraParametro.Desativado = false;
                compraParametro.Observacao = obsParametro;

                if (valorCompraParametro == "")
                    compraParametro.ValorCompra = 0;
                else
                    compraParametro.ValorCompra = Convert.ToDecimal(valorCompraParametro);
                
                if (valorDescontoParametro == "")
                    compraParametro.ValorDesconto = 0;
                else
                    compraParametro.ValorDesconto = Convert.ToDecimal(valorDescontoParametro);                
                /*
                foreach (DataGridViewRow linha in data.Rows)
                {
                    if (linha.Index < (data.Rows.Count))
                    {
                        ItemCompra itemCompra = new ItemCompra();
                        itemCompra.Produto = produtoControle.Buscar(Convert.ToInt32((linha.Cells[0].Value)));
                        itemCompra.Desativado = false;
                        itemCompra.Quantidade = Convert.ToInt32(linha.Cells[3].Value);                        
                        itemCompra.ValorUnitario = Convert.ToDecimal(linha.Cells[2].Value);
                        itemCompra.ValorTotal = Convert.ToDecimal(linha.Cells[4].Value);                       
                        itemCompra.Compra = compra;
                        compra.ItemCompra.Add(itemCompra);
                    }
                }  */              
                compraControle = new CompraControle(loja);

                compraControle.Salvar(compraParametro);                
                
                return true;
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
                return false;
            }	
        }

        public Boolean AtualizaCompra(Compra compraParametro, 
                                      String descontoParametro, 
                                      String valorCompraParametro, 
                                      Int32  cadastroParametro,
                                      String obsParametro,
                                      Boolean atualizaParametro)
        {
            try
            {
                compraParametro.ValorCompra = Convert.ToDecimal(valorCompraParametro);
                compraParametro.ValorDesconto = Convert.ToDecimal(descontoParametro);
                compraParametro.Cadastro = cliente.Buscar(cadastroParametro);
                compraParametro.Observacao = obsParametro;                
                compraParametro.Status = atualizaParametro;
                
                compraControle.Atualizar(compraParametro);
                
                return true;
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
                return false;
            }
        }

        public Object BuscaCompra(Int32 compraParametro)
        {
            compraControle = new CompraControle(loja);
            return compraControle.BuscaCompra(compraParametro);   
        }

        public Object BuscaCompra(DateTime dataInicio, DateTime dataFim)
        {
            compraControle = new CompraControle(loja);
            return compraControle.BuscaCompra(dataInicio, dataFim);
        }
    }
}
